//============================================================================
// Name        : main.cpp
// Author      : Giuliana Silva Bezerra
// Version     :
// Copyright   : Your copyright notice
// Description : Frames recording and face recognition
//============================================================================

#include "opencv2/objdetect/objdetect.hpp"
#include "opencv2/highgui/highgui.hpp"
#include "opencv2/imgproc/imgproc.hpp"
#include <string.h>
#include <pthread.h>

#include <iostream>
#include <iterator>
#include <stdio.h>

using namespace std;
using namespace cv;

pthread_t threads[3];
pthread_attr_t attr;
CvCapture* capture = 0;
int i = 0;
Mat frame, frameCopy, image;
const string scaleOpt = "--scale=";
size_t scaleOptLen = scaleOpt.length();
const string cascadeOpt = "--cascade=";
size_t cascadeOptLen = cascadeOpt.length();
const string nestedCascadeOpt = "--nested-cascade";
size_t nestedCascadeOptLen = nestedCascadeOpt.length();
const string tryFlipOpt = "--try-flip";
size_t tryFlipOptLen = tryFlipOpt.length();
string inputName;
bool tryflip = false;
CascadeClassifier cascade, nestedCascade;
double scale = 1;
char track;
int id;

void detectAndDraw(Mat& img, CascadeClassifier& cascade,
		CascadeClassifier& nestedCascade, double scale, bool tryflip);

string cascadeName = "config/haarcascade_frontalface_alt.xml";
string nestedCascadeName = "config/haarcascade_eye_tree_eyeglasses.xml";

IplImage* skipNFrames(CvCapture* capture, int n) {
	for (int i = 0; i < n; ++i) {
		if (cvQueryFrame(capture) == NULL) {
			return NULL;
		}
	}

	return cvQueryFrame(capture);
}

void * loadEnd(void * t) {
	pthread_join(threads[0], 0);
	pthread_join(threads[1], 0);
	IplImage * image = cvLoadImage("FIM.jpg");
	cvShowImage("INFO", image);
	// Espera apertar uma tecla pra fechar a janela de visualizacao.
	cvWaitKey(0);

	//libera os recursos usados pela imagem.
	cvReleaseImage(&image);
	pthread_exit(NULL);
}

void * play(void *t) {
	//system("mpg321 audio/track3-h.mp3");
	if (track == 's')
		system("mpg321 audio/track1-s.mp3");
	else if (track == 'f')
		system("mpg321 audio/track2-f.mp3");
	else if (track == 'h')
		system("mpg321 audio/track3-h.mp3");
	//system("/home/giuliana/workspace_cpp/framerecord/audio/track3-h.mp3");
	pthread_cancel(threads[1]);
	cvReleaseCapture(&capture);
	pthread_exit(NULL);
}

void * captureCam(void * t) {
	capture = cvCaptureFromCAM(
			inputName.empty() ? 0 : inputName.c_str()[0] - '0');
	int c = inputName.empty() ? 0 : inputName.c_str()[0] - '0';
	if (!capture)
		cout << "Capture from CAM " << c << " didn't work" << endl;
	/*}
	 else if( inputName.size() )
	 {
	 image = imread( inputName, 1 );
	 if( image.empty() )
	 {
	 capture = cvCaptureFromAVI( inputName.c_str() );
	 if(!capture) cout << "Capture from AVI didn't work" << endl;
	 }
	 }
	 else
	 {
	 image = imread( "lena.jpg", 1 );
	 if(image.empty()) cout << "Couldn't read lena.jpg" << endl;
	 }*/

	//cvNamedWindow("result", 1);
	if (capture) {
		cout << "In capture ..." << endl;
		cvSetCaptureProperty(capture, CV_CAP_PROP_FPS, 1);
		for (;;) {

			IplImage* iplImg = skipNFrames(capture, 5);
			frame = iplImg;
			if (frame.empty())
				break;
			if (iplImg->origin == IPL_ORIGIN_TL) {
				frame.copyTo(frameCopy);
				ostringstream convert, convert1;
				convert1 << "mkdir img/" << id;
				system(convert1.str().c_str());
				convert << "img/" << id << "/frame" << i << ".jpg";
				cvSaveImage(convert.str().c_str(), iplImg);
				i++;
				/*char * buffer = NULL;
				 sprintf(buffer,"image%d.jpg",i);
				 cout<<buffer;
				 //Cria nova imagem com histograma equalizado.
				 cvSaveImage(buffer, iplImg);
				 i++;*/
			} else
				flip(frame, frameCopy, 0);

			//detectAndDraw(frameCopy, cascade, nestedCascade, scale, tryflip);

			if (waitKey(1) >= 0)
				goto _cleanup_;
		}

		_cleanup_: cvReleaseCapture(&capture);
	} else {
		cout << "In image read" << endl;
		if (!image.empty()) {
			//detectAndDraw(image, cascade, nestedCascade, scale, tryflip);
			waitKey(0);
		} else if (!inputName.empty()) {
			/* assume it is a text file containing the
			 list of the image filenames to be processed - one per line */
			FILE* f = fopen(inputName.c_str(), "rt");
			if (f) {
				char buf[1000 + 1];
				while (fgets(buf, 1000, f)) {
					int len = (int) strlen(buf), c;
					while (len > 0 && isspace(buf[len - 1]))
						len--;
					buf[len] = '\0';
					cout << "file " << buf << endl;
					image = imread(buf, 1);
					if (!image.empty()) {
						//detectAndDraw(image, cascade, nestedCascade, scale,
						//		tryflip);
						c = waitKey(0);
						if (c == 27 || c == 'q' || c == 'Q')
							break;
					} else {
						cerr << "Aw snap, couldn't read image " << buf << endl;
					}
				}
				fclose(f);
			}
		}
	}

	cvDestroyWindow("result");
	pthread_exit(NULL);
}

int main(int argc, const char** argv) {
	//for (int i = 1; i < argc; i++) {
	//}
//		cout << "Processing " << i << " " << argv[i] << endl;
//		if (cascadeOpt.compare(0, cascadeOptLen, argv[i], cascadeOptLen) == 0) {
//			cascadeName.assign(argv[i] + cascadeOptLen);
//			cout << "  from which we have cascadeName= " << cascadeName << endl;
//		} else if (nestedCascadeOpt.compare(0, nestedCascadeOptLen, argv[i],
//				nestedCascadeOptLen) == 0) {
//			if (argv[i][nestedCascadeOpt.length()] == '=')
//				nestedCascadeName.assign(
//						argv[i] + nestedCascadeOpt.length() + 1);
//			if (!nestedCascade.load(nestedCascadeName))
//				cerr
//						<< "WARNING: Could not load classifier cascade for nested objects"
//						<< endl;
//		} else if (scaleOpt.compare(0, scaleOptLen, argv[i], scaleOptLen)
//				== 0) {
//			if (!sscanf(argv[i] + scaleOpt.length(), "%lf", &scale)
//					|| scale < 1)
//				scale = 1;
//			cout << " from which we read scale = " << scale << endl;
//		} else if (tryFlipOpt.compare(0, tryFlipOptLen, argv[i], tryFlipOptLen)
//				== 0) {
//			tryflip = true;
//			cout
//					<< " will try to flip image horizontally to detect assymetric objects\n";
//		} else if (argv[i][0] == '-') {
//			cerr << "WARNING: Unknown option %s" << argv[i] << endl;
//		} else
//			inputName.assign(argv[i]);
//	}

//	if (!cascade.load(cascadeName)) {
//		cerr << "ERROR: Could not load classifier cascade" << endl;
//		return -1;
//	}

	//if( inputName.empty() || (isdigit(inputName.c_str()[0]) && inputName.c_str()[1] == '\0') )
	//{
	//Play the song
	//system("mpg321 audio/track2-f.mp3");
	// Initialize and set thread joinable
	cout<<"ID and track: "<<endl;
	cin>>id>>track;

	cvNamedWindow("INFO", 0);
	//cvResizeWindow("INFO",1400,768);
	cvSetWindowProperty("INFO", CV_WND_PROP_FULLSCREEN, CV_WINDOW_FULLSCREEN);

	pthread_attr_init(&attr);
	pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);

	pthread_create(&threads[0], NULL, play, (void *) 0);
	pthread_create(&threads[1], NULL, captureCam, (void *) 0);
	pthread_create(&threads[2], NULL, loadEnd, (void *) 0);

	pthread_exit(NULL);
	return 0;
}

void detectAndDraw(Mat& img, CascadeClassifier& cascade,
		CascadeClassifier& nestedCascade, double scale, bool tryflip) {
	int i = 0;
	double t = 0;
	vector<Rect> faces, faces2;
	const static Scalar colors[] = { CV_RGB(0,0,255),
	CV_RGB(0,128,255),
	CV_RGB(0,255,255),
	CV_RGB(0,255,0),
	CV_RGB(255,128,0),
	CV_RGB(255,255,0),
	CV_RGB(255,0,0),
	CV_RGB(255,0,255) };
	Mat gray, smallImg(cvRound(img.rows / scale), cvRound(img.cols / scale),
	CV_8UC1);

	cvtColor(img, gray, CV_BGR2GRAY);
	resize(gray, smallImg, smallImg.size(), 0, 0, INTER_LINEAR);
	equalizeHist(smallImg, smallImg);

	t = (double) cvGetTickCount();
	cascade.detectMultiScale(smallImg, faces, 1.1, 2, 0
	//|CV_HAAR_FIND_BIGGEST_OBJECT
	//|CV_HAAR_DO_ROUGH_SEARCH
			| CV_HAAR_SCALE_IMAGE, Size(30, 30));
	if (tryflip) {
		flip(smallImg, smallImg, 1);
		cascade.detectMultiScale(smallImg, faces2, 1.1, 2, 0
		//|CV_HAAR_FIND_BIGGEST_OBJECT
		//|CV_HAAR_DO_ROUGH_SEARCH
				| CV_HAAR_SCALE_IMAGE, Size(30, 30));
		for (vector<Rect>::const_iterator r = faces2.begin(); r != faces2.end();
				r++) {
			faces.push_back(
					Rect(smallImg.cols - r->x - r->width, r->y, r->width,
							r->height));
		}
	}
	t = (double) cvGetTickCount() - t;
	printf("detection time = %g ms\n",
			t / ((double) cvGetTickFrequency() * 1000.));
	for (vector<Rect>::const_iterator r = faces.begin(); r != faces.end();
			r++, i++) {
		Mat smallImgROI;
		vector<Rect> nestedObjects;
		Point center;
		Scalar color = colors[i % 8];
		int radius;

		double aspect_ratio = (double) r->width / r->height;
		if (0.75 < aspect_ratio && aspect_ratio < 1.3) {
			center.x = cvRound((r->x + r->width * 0.5) * scale);
			center.y = cvRound((r->y + r->height * 0.5) * scale);
			radius = cvRound((r->width + r->height) * 0.25 * scale);
			circle(img, center, radius, color, 3, 8, 0);
		} else
			rectangle(img,
					cvPoint(cvRound(r->x * scale), cvRound(r->y * scale)),
					cvPoint(cvRound((r->x + r->width - 1) * scale),
							cvRound((r->y + r->height - 1) * scale)), color, 3,
					8, 0);
		if (nestedCascade.empty())
			continue;
		smallImgROI = smallImg(*r);
		nestedCascade.detectMultiScale(smallImgROI, nestedObjects, 1.1, 2, 0
		//|CV_HAAR_FIND_BIGGEST_OBJECT
		//|CV_HAAR_DO_ROUGH_SEARCH
		//|CV_HAAR_DO_CANNY_PRUNING
				| CV_HAAR_SCALE_IMAGE, Size(30, 30));
		for (vector<Rect>::const_iterator nr = nestedObjects.begin();
				nr != nestedObjects.end(); nr++) {
			center.x = cvRound((r->x + nr->x + nr->width * 0.5) * scale);
			center.y = cvRound((r->y + nr->y + nr->height * 0.5) * scale);
			radius = cvRound((nr->width + nr->height) * 0.25 * scale);
			circle(img, center, radius, color, 3, 8, 0);
		}
	}
	cv::imshow("result", img);
}
